home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 February: Technology Seed / Mac Tech Seed Feb '97.toast / OpenDoc 1.2b2c1 / Implementation / Binding / ODBindng.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-02-13  |  18.7 KB  |  756 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        ODBindng.cpp
  3.  
  4.     Contains:    SOM Implementation for Binding class.
  5.  
  6.     Owned by:    Caia Grisar
  7.  
  8.     Copyright:    © 1993 - 1996 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.  
  12.          <7>     10/4/96    EL        1343891: use kODFileFromEditor instead of
  13.                                     hard coded constant
  14.          <6>     9/17/96    RA        1370339: Added WARN if NoPart fails to be
  15.                                     created
  16.          <5>     6/27/96    RA        Don't dereference null structs
  17.          <4>     6/24/96    RA        T10025: Made new Binding API CORBA
  18.                                     compliant. Added ODGetFileFromEditor
  19.                                     method.
  20.          <3>     6/21/96    RA        T10025: Added new Binding API
  21.         <13>     10/8/95    TJ        Fixes Recomended by Refball
  22.         <12>      8/3/95    RR        #1257260: Collapse B classes. Remove
  23.                                     somInit methods. Don't call IsInitialized
  24.                                     or SubclassResponsibility
  25.         <11>     7/24/95    CG        1270320: Memory leak fixes.
  26.         <10>     5/18/95    CG        #1241621 BB: Need to implement Purge for
  27.                                     Binding subsystem objects.
  28.          <9>     5/17/95    VL        1170098: Added private-by-convention
  29.                                     ConstructNoPart.
  30.          <8>      5/1/95    CG        #1241628    BB: SOM_TRY blocks needed in
  31.                                     Binding SOM methods. #1243669    XMP in
  32.                                     ODBindng.cpp ifdef
  33.          <7>     4/26/95    CG        last check in comment should have been :
  34.                                     1241628    SOM_TRY blocks needed in Binding
  35.                                     SOM methods.
  36.          <6>     4/26/95    CG        1211082 BB: 5$ Bugs need to be evaluated
  37.                                     and removed from Core
  38.          <5>    12/13/94    CG        #1206024: Added function prefix to .idl
  39.                                     file.
  40.          <4>     8/24/94    CG        #1181622: Updated file ownership.
  41.          <3>     8/17/94    CG        #1181519: The Binding helper object was not
  42.                                     getting initialized  in InitBinding.
  43.          <2>      7/1/94    CG        Check for somSelf->IsInitialized in
  44.                                     InitBinding.
  45.          <1>     6/20/94    CG        first checked in
  46.     To Do:
  47. */
  48.  
  49. #define ODBinding_Class_Source
  50. #define VARIABLE_MACROS
  51. #include <ODBindng.xih>
  52.  
  53. #ifndef _BINDNGH_
  54. #include "BindngH.h"
  55. #endif
  56.  
  57. #ifndef SOM_ODSession_xh
  58. #include <ODSessn.xh>
  59. #endif
  60.  
  61. #ifndef SOM_Module_Apple_defined
  62. #include <NoPart.xh>
  63. #endif
  64.  
  65. #ifndef SOM_ODNameSpaceManager_xh
  66. #include <NmSpcMg.xh>
  67. #endif
  68.  
  69. #ifndef SOM_ODObjectNameSpace_xh
  70. #include <ObjectNS.xh>
  71. #endif
  72.  
  73. #ifndef SOM_ODObjectIterator_xh
  74. #include <ObjctItr.xh>
  75. #endif
  76.  
  77. #ifndef SOM_ODTypeList_xh
  78. #include <TypeList.xh>
  79. #endif
  80.  
  81. #ifndef SOM_ODTypeListIterator_xh
  82. #include <TypLsItr.xh>
  83. #endif
  84.  
  85. #ifndef SOM_ODStorageSystem_xh
  86. #include <ODStor.xh>
  87. #endif
  88.  
  89. #ifndef SOM_ODValueNameSpace_xh
  90. #include <ValueNS.xh>
  91. #endif
  92.  
  93. #ifndef _ISOSTR_
  94. #include "ISOStr.h"
  95. #endif
  96.  
  97. #ifndef _NMSPCUTL_
  98. #include "NmSpcUtl.h"
  99. #endif
  100.  
  101. #ifndef _BARRAY_
  102. #include "BArray.h"
  103. #endif
  104.  
  105.  
  106. SOM_Scope ODBoolean  SOMLINK ODBindingGetODFileSpecFromEditor(ODBinding *somSelf, Environment *ev,
  107.         ODEditor editor,
  108.         ODByteArray* fileSpec)
  109. {
  110.     ODBindingData *somThis = ODBindingGetData(somSelf);
  111.     ODBindingMethodDebug("ODBinding","ODBindingGetFileFromEditor");
  112.     
  113.     ODBoolean result = kODFalse;
  114.     
  115.     SOM_TRY
  116.     
  117.     Environment* ev = somGetGlobalEnvironment();
  118.  
  119.     ODValueNameSpace* fileFromEditorNS = 
  120.         (ODValueNameSpace*)_fNmSpcMgr->HasNameSpace( ev, kODFileFromEditor );
  121.  
  122.     if ( fileFromEditorNS )
  123.     {
  124.         ODFileSpec* fsspecPtr = kODNULL;
  125.         ODULong     valueLength;
  126.         
  127.         result = ValueNameSpaceGetEntry( fileFromEditorNS, 
  128.                             ev,  editor, (ODPtr*) &fsspecPtr,  &valueLength);
  129.         if (result)
  130.         {            
  131.              UseByteArray(fileSpec, fsspecPtr, sizeof(ODFileSpec)); // place contents of FSSpec into byteArray
  132.         }
  133.         else
  134.             fileSpec->_buffer = kODNULL;
  135.     }
  136.     
  137.     SOM_CATCH_ALL
  138.     SOM_ENDTRY
  139.     
  140.     return result;
  141.     
  142. }
  143.  
  144. SOM_Scope void  SOMLINK ODBindingInitBinding(ODBinding *somSelf, Environment *ev,
  145.         ODSession* session)
  146. {
  147.     ODBindingData *somThis = ODBindingGetData(somSelf);
  148.     ODBindingMethodDebug("ODBinding","InitBinding");
  149.  
  150.     SOM_TRY
  151.     
  152.     somSelf->InitObject(ev);
  153.         
  154.     _fSession = session;
  155.     _fNmSpcMgr = session->GetNameSpaceManager(ev);
  156.     _fBinding = new Binding();
  157.     _fBinding->InitBinding(_fSession);
  158.     
  159.     SOM_CATCH_ALL
  160.     SOM_ENDTRY
  161. }
  162.  
  163. SOM_Scope ODPart*  SOMLINK ODBindingConstructNoPart(ODBinding *somSelf, Environment *ev)
  164. {
  165.     ODBindingData *somThis = ODBindingGetData(somSelf);
  166.     ODBindingMethodDebug("ODBinding","ConstructNoPart");
  167.  
  168.     ODPart*    noPart = kODNULL; ODVolatile(noPart);
  169.      
  170.     SOM_TRY
  171.     
  172.     noPart = new Apple_NoPart;
  173.     
  174.     SOM_CATCH_ALL
  175.         TRY
  176.             WARN("ConstructNoPart failed to create a NoPart!");
  177.         CATCH_ALL
  178.         ENDTRY
  179.         
  180.         noPart = kODNULL;
  181.     SOM_ENDTRY
  182.     return noPart;
  183. }
  184.  
  185. SOM_Scope ODEditor  SOMLINK ODBindingChooseEditorForPart(ODBinding *somSelf, Environment *ev,
  186.         ODStorageUnit* thePartSU,
  187.         ODType newKind)
  188. {
  189.     ODBindingData *somThis = ODBindingGetData(somSelf);
  190.     ODBindingMethodDebug("ODBinding","ChooseEditorForPart");
  191.  
  192.      ODEditor returnVal = kODNULL;
  193.  
  194.     SOM_TRY
  195.  
  196.     returnVal = _fBinding->ChooseEditorForPart(thePartSU, newKind);
  197.  
  198.     SOM_CATCH_ALL
  199.     SOM_ENDTRY
  200.  
  201.     return (returnVal);
  202. }
  203.  
  204. SOM_Scope ODContainerSuite  SOMLINK ODBindingGetContainerSuite(ODBinding *somSelf, Environment *ev,
  205.         ODContainerType containerType)
  206. {
  207.     ODBindingData *somThis = ODBindingGetData(somSelf);
  208.     ODBindingMethodDebug("ODBinding","GetContainerSuite");
  209.  
  210.     ODContainerSuite returnVal = kODNULL;
  211.  
  212.     SOM_TRY
  213.  
  214.     returnVal = _fBinding->GetContainerSuite( containerType );
  215.  
  216.     SOM_CATCH_ALL
  217.     SOM_ENDTRY
  218.  
  219.     return (returnVal);
  220. }
  221.  
  222. SOM_Scope ODTypeList*  SOMLINK ODBindingGetAllCategoriesForKind(ODBinding *somSelf, Environment *ev,
  223.         ODKind kind)
  224. {
  225.     ODBindingData *somThis = ODBindingGetData(somSelf);
  226.     ODBindingMethodDebug("ODBinding","ODBindingGetAllCategoriesForKind");
  227.  
  228.     ODTypeList*    categoryList = kODNULL;
  229.     
  230.     SOM_TRY
  231.         // look it up in the kindcategory namespace
  232.     ODObjectNameSpace* kindCategoryNameSpace = 
  233.         (ODObjectNameSpace*)_fNmSpcMgr->HasNameSpace( ev, kODKind );
  234.     
  235.     if (kindCategoryNameSpace)
  236.     {
  237.         if (kindCategoryNameSpace->GetEntry(ev, (ODISOStr)kind, 
  238.                                         (ODObject**)&categoryList ))
  239.             return categoryList;
  240.         else
  241.             return kODNULL;
  242.     }
  243.     
  244.     SOM_CATCH_ALL
  245.     SOM_ENDTRY
  246.     
  247.     return categoryList;
  248. }
  249.  
  250.  
  251. SOM_Scope ODBoolean  SOMLINK ODBindingGetAllEditorsForKind(ODBinding *somSelf, Environment *ev,
  252.         ODKind kind,
  253.         ODTypeList* editorList)
  254. {
  255.     ODBindingData *somThis = ODBindingGetData(somSelf);
  256.     ODBindingMethodDebug("ODBinding","ODBindingGetAllEditorsForKind");
  257.  
  258.     ODTypeList*            kindsList     = kODNULL;
  259.     ODEditor             editor         = kODNULL; ODVolatile(editor);
  260.     ODObjectIterator*     iter         = kODNULL; ODVolatile(iter);
  261.     ODULong                len         = 0;
  262.     ODBoolean            retval         = kODFalse;
  263.  
  264.     SOM_TRY
  265.     
  266.     if (editorList)
  267.     {
  268.             // get the editorkinds namespace
  269.         ODObjectNameSpace* editorkindsNameSpace = 
  270.             (ODObjectNameSpace*)_fNmSpcMgr->HasNameSpace( ev, kODEditorKinds );
  271.         
  272.         if (editorkindsNameSpace)
  273.         {
  274.                 //    iterate through editorKinds namespace
  275.             iter = editorkindsNameSpace->CreateIterator(ev) ;
  276.             for (iter->First(ev, (ODISOStr*)&editor, (ODObject**)&kindsList, &len);
  277.                     iter->IsNotComplete(ev);
  278.                     iter->Next(ev, (ODISOStr*)&editor, (ODObject**)&kindsList, &len))
  279.             {
  280.                 if ( kindsList )
  281.                 {
  282.                     if ( kindsList->Contains(ev, kind) )
  283.                     {
  284.                         editorList->AddLast(ev, editor);
  285.                         retval = kODTrue;
  286.                     }
  287.                     ODDisposePtr( editor );
  288.                 }
  289.             }
  290.             ODDeleteObject( iter );
  291.         }
  292.     }
  293.     SOM_CATCH_ALL
  294.         ODDeleteObject(iter);
  295.         ODDeleteObject(editor);
  296.     SOM_ENDTRY
  297.     
  298.     return retval;
  299. }
  300.  
  301. SOM_Scope void  SOMLINK ODBindingGetAllKindsForEditor(ODBinding *somSelf, Environment *ev,
  302.         ODEditor editor,
  303.         ODTypeList* kindList)
  304. {
  305.     ODBindingData *somThis = ODBindingGetData(somSelf);
  306.     ODBindingMethodDebug("ODBinding","ODBindingGetAllKindsForEditor");
  307.  
  308.     ODTypeListIterator* iter = kODNULL; ODVolatile(iter);
  309.  
  310.     SOM_TRY
  311.     
  312.     if (kindList)
  313.     {
  314.             // get the editorkinds namespace
  315.         ODObjectNameSpace* editorkindsNameSpace = 
  316.             (ODObjectNameSpace*)_fNmSpcMgr->HasNameSpace( ev, kODEditorKinds );
  317.         
  318.         if (editorkindsNameSpace)
  319.         {
  320.             ODTypeList*    nsKindsList = kODNULL;
  321.             ODType        kind         = kODNULL;
  322.             if(editorkindsNameSpace->GetEntry( ev, (ODType)editor, 
  323.                                                      (ODObject**)&nsKindsList ))
  324.             {
  325.                 iter = nsKindsList->CreateTypeListIterator(ev);
  326.                 for (kind = iter->First(ev);
  327.                         iter->IsNotComplete(ev);
  328.                         kind = iter->Next(ev))
  329.                 {
  330.                     kindList->AddLast(ev, kind);
  331.                     ODDisposePtr(kind);
  332.                 }
  333.                 
  334.                 ODDeleteObject( iter );
  335.             }
  336.         }
  337.     }
  338.     SOM_CATCH_ALL
  339.         ODDeleteObject(iter);
  340.     SOM_ENDTRY
  341. }
  342.  
  343. SOM_Scope ODBoolean  SOMLINK ODBindingGetAllEditorsForCategory(ODBinding *somSelf, Environment *ev,
  344.         ODCategory category,
  345.         ODTypeList* editorList)
  346. {
  347.     ODBindingData *somThis = ODBindingGetData(somSelf);
  348.     ODBindingMethodDebug("ODBinding","ODBindingGetAllEditorsForCategory");
  349.     
  350.     ODBoolean             retval             = kODFalse;
  351.     ODTypeListIterator* esi             = kODNULL; ODVolatile(esi);
  352.     ODObjectIterator*     iter             = kODNULL; ODVolatile(iter);
  353.     ODTypeList*         thisEditorSet     = kODNULL; ODVolatile(thisEditorSet);
  354.     ODULong    len;
  355.     
  356.     SOM_TRY
  357.     
  358.     ODObjectNameSpace* kindCategories = 
  359.         (ODObjectNameSpace*)_fNmSpcMgr->HasNameSpace( ev, kODKind ) ;
  360.     if ( kindCategories )
  361.     {
  362.         ODTypeList*         categoriesList  = kODNULL;
  363.         ODType                 kind;
  364.  
  365.         iter = kindCategories->CreateIterator(ev) ;
  366.         for (iter->First(ev, (ODISOStr*)&kind, (ODObject**)&categoriesList, &len);
  367.                 iter->IsNotComplete(ev);
  368.                 iter->Next(ev, (ODISOStr*)&kind, (ODObject**)&categoriesList, &len))
  369.         {
  370.             if ( categoriesList && categoriesList->Contains( ev, category ) )
  371.             {
  372.                 thisEditorSet = _fSession->GetStorageSystem(ev)->CreateTypeList(ev,kODNULL);
  373.                 
  374.                 if ( somSelf->GetAllEditorsForKind(ev,
  375.                                             kind, thisEditorSet ) )
  376.                 {    
  377.                         esi = thisEditorSet->CreateTypeListIterator(ev);
  378.                         for ( ODEditor editor = esi->First(ev) ; esi->IsNotComplete(ev) ;
  379.                                 editor = esi->Next(ev) )
  380.                         {
  381.                             editorList->AddLast(ev, editor);
  382.                         }
  383.                         ODDeleteObject( esi );
  384.                         
  385.                         retval = kODTrue;
  386.                 }
  387.                 ODDeleteObject( thisEditorSet );
  388.             }
  389.         }
  390.         ODDeleteObject( iter );
  391.     }
  392.     
  393.     SOM_CATCH_ALL
  394.             ODDeleteObject( thisEditorSet );
  395.             ODDeleteObject( iter );
  396.             ODDeleteObject( esi );
  397.     SOM_ENDTRY
  398.     
  399.     return retval ;
  400. }
  401.  
  402. SOM_Scope ODEditor  SOMLINK ODBindingSetSysPrefEditorForKind(ODBinding *somSelf, Environment *ev,
  403.         ODEditor editor,
  404.         ODKind kind)
  405. {
  406.     ODBindingData *somThis = ODBindingGetData(somSelf);
  407.     ODBindingMethodDebug("ODBinding","ODBindingSetSysPrefEditorForKind");
  408.  
  409.     ODEditor setEditor = kODNULL; ODVolatile(setEditor);
  410.     
  411.         // look it up in the editorkinds namespace
  412.     SOM_TRY
  413.     
  414.     ODValueNameSpace* sysPrefEditorKindsNameSpace = 
  415.         (ODValueNameSpace*)_fNmSpcMgr->HasNameSpace( ev, 
  416.                                                         kODSysPrefEditorKinds );
  417.     
  418.     if (sysPrefEditorKindsNameSpace)
  419.     {
  420.         ODULong strLength = ODISOStrLength((const ODISOStr)editor);
  421.         setEditor = (ODEditor)ODNewPtrClear(strLength+1, kDefaultHeapID);
  422.         ODISOStrNCopy((ODISOStr)setEditor,(const ODISOStr)editor, strLength);
  423.         ValueNameSpaceRegister( sysPrefEditorKindsNameSpace, ev, (ODISOStr)kind, 
  424.                                             (ODPtr)setEditor, strLength+1 );
  425.         _fNmSpcMgr->UpdatePreferences(ev);
  426.     }
  427.     
  428.     SOM_CATCH_ALL
  429.         ODDeleteObject(setEditor);
  430.     SOM_ENDTRY
  431.     
  432.     return setEditor;
  433. }
  434.  
  435. SOM_Scope ODEditor  SOMLINK ODBindingSetSysPrefEditorForCategory(ODBinding *somSelf, Environment *ev,
  436.         ODEditor editor,
  437.         ODCategory category)
  438. {
  439.     ODBindingData *somThis = ODBindingGetData(somSelf);
  440.     ODBindingMethodDebug("ODBinding","ODBindingSetSysPrefEditorForCategory");
  441.  
  442.     ODEditor setEditor = kODNULL; ODVolatile(setEditor);
  443.     
  444.     SOM_TRY
  445.     
  446.     // look it up in the editorkinds namespace
  447.     ODValueNameSpace* sysPrefEditorCategoriesNameSpace = 
  448.         (ODValueNameSpace*)_fNmSpcMgr->HasNameSpace( ev, 
  449.                                                    kODSysPrefEditorCategories );
  450.     
  451.     if (sysPrefEditorCategoriesNameSpace)
  452.     {
  453.         ODULong strLength = ODISOStrLength((const ODISOStr)editor);
  454.         setEditor = (ODEditor)ODNewPtrClear(strLength+1, kDefaultHeapID);
  455.         ODISOStrNCopy((ODISOStr)setEditor,(const ODISOStr)editor, strLength);
  456.         ValueNameSpaceRegister( sysPrefEditorCategoriesNameSpace, ev, 
  457.                                 (ODISOStr)category, (ODPtr)setEditor, strLength+1);
  458.         _fNmSpcMgr->UpdatePreferences(ev);
  459.     }
  460.     
  461.     SOM_CATCH_ALL
  462.         ODDeleteObject(setEditor);
  463.     SOM_ENDTRY
  464.     
  465.     return setEditor;
  466. }
  467.  
  468. SOM_Scope ODEditor  SOMLINK ODBindingGetSysPrefEditorForKind(ODBinding *somSelf, Environment *ev,
  469.         ODKind kind)
  470. {
  471.     ODBindingData *somThis = ODBindingGetData(somSelf);
  472.     ODBindingMethodDebug("ODBinding","ODBindingGetSysPrefEditorForKind");
  473.  
  474.      ODEditor     theEditor             = kODNULL;
  475.     
  476.     SOM_TRY
  477.     
  478.         // look it up in the editorkinds namespace
  479.     ODValueNameSpace* sysPrefEditorKindsNameSpace = 
  480.         (ODValueNameSpace*)_fNmSpcMgr->HasNameSpace( ev, 
  481.                                                         kODSysPrefEditorKinds );
  482.     if (sysPrefEditorKindsNameSpace)
  483.     {
  484.         ODULong        valueLen = 0;
  485.         ODBoolean     sysPrefEditorFound = kODFalse;
  486.  
  487.         sysPrefEditorFound = ValueNameSpaceGetEntry( 
  488.                                 sysPrefEditorKindsNameSpace, ev, kind, 
  489.                                 (ODPtr*) &theEditor, &valueLen );
  490.     }
  491.     
  492.     SOM_CATCH_ALL
  493.     SOM_ENDTRY
  494.     
  495.     return theEditor;
  496. }
  497.  
  498. SOM_Scope ODEditor  SOMLINK ODBindingGetSysPrefEditorForCategory(ODBinding *somSelf, Environment *ev,
  499.         ODCategory category)
  500. {
  501.     ODBindingData *somThis = ODBindingGetData(somSelf);
  502.     ODBindingMethodDebug("ODBinding","ODBindingGetSysPrefEditorForCategory");
  503.  
  504.      ODEditor theEditor = kODNULL;
  505.     
  506.     SOM_TRY
  507.     
  508.         // look it up in the editorkinds namespace
  509.     ODValueNameSpace* sysPrefEditorCategoriesNameSpace = 
  510.         (ODValueNameSpace*)_fNmSpcMgr->HasNameSpace( ev, 
  511.                                                    kODSysPrefEditorCategories );
  512.     
  513.     if (sysPrefEditorCategoriesNameSpace)
  514.     {
  515.         ODULong        valueLen = 0;
  516.         ODBoolean     sysPrefEditorFound = kODFalse;
  517.  
  518.         sysPrefEditorFound = ValueNameSpaceGetEntry( 
  519.                                 sysPrefEditorCategoriesNameSpace, ev, category, 
  520.                                 (ODPtr*) &theEditor, &valueLen );
  521.     }
  522.     
  523.     SOM_CATCH_ALL
  524.     SOM_ENDTRY
  525.     
  526.     return theEditor;
  527. }
  528.  
  529.  
  530. SOM_Scope ODBoolean  SOMLINK ODBindingGetUserStringForKind(ODBinding *somSelf, Environment *ev,
  531.         ODKind kind,
  532.         ODName* name)
  533. {
  534.     ODBindingData *somThis = ODBindingGetData(somSelf);
  535.     ODBindingMethodDebug("ODBinding","ODBindingGetUserStringForKind");
  536.     
  537.     ODBoolean    result  = kODFalse ;
  538.     ODName*        userString = kODNULL;
  539.     
  540.     SOM_TRY
  541.     
  542.         // look it up in the spaceName namespace
  543.     ODValueNameSpace* userStringNameSpace = 
  544.         (ODValueNameSpace*)_fNmSpcMgr->HasNameSpace( ev, kODKindUserString );
  545.  
  546.     if (userStringNameSpace)
  547.         result = ValueNameSpaceGetODName(userStringNameSpace, ev, kind, &userString );
  548.         
  549.     if (userString)
  550.         *name = *userString;
  551.     else
  552.         InitIText(name);
  553.     
  554.     SOM_CATCH_ALL
  555.     SOM_ENDTRY
  556.     
  557.     return result ;
  558. }
  559.  
  560. SOM_Scope ODBoolean  SOMLINK ODBindingGetUserStringForEditor(ODBinding *somSelf, Environment *ev,
  561.         ODEditor editor,
  562.         ODName* name)
  563. {
  564.     ODBindingData *somThis = ODBindingGetData(somSelf);
  565.     ODBindingMethodDebug("ODBinding","ODBindingGetUserStringForEditor");
  566.  
  567.     ODBoolean    result  = kODFalse ;
  568.     ODName*        userString = kODNULL;
  569.  
  570.     SOM_TRY
  571.     
  572.         // look it up in the spaceName namespace
  573.     ODValueNameSpace* userStringNameSpace = 
  574.         (ODValueNameSpace*)_fNmSpcMgr->HasNameSpace( ev, kODEditorUserString );
  575.  
  576.     if (userStringNameSpace)
  577.         result = ValueNameSpaceGetODName(userStringNameSpace, ev, editor, &userString );
  578.     
  579.     if (userString)
  580.         *name = *userString;
  581.     else
  582.         InitIText(name);
  583.     
  584.     SOM_CATCH_ALL
  585.     SOM_ENDTRY
  586.     
  587.     return result ;
  588. }
  589.  
  590. SOM_Scope ODBoolean  SOMLINK ODBindingGetUserStringForCategory(ODBinding *somSelf, Environment *ev,
  591.         ODCategory category,
  592.         ODName* name)
  593. {
  594.     ODBindingData *somThis = ODBindingGetData(somSelf);
  595.     ODBindingMethodDebug("ODBinding","ODBindingGetUserStringForCategory");
  596.  
  597.     ODBoolean    result  = kODFalse ;
  598.     ODName*        userString = kODNULL;
  599.  
  600.     SOM_TRY
  601.     
  602.         // look it up in the spaceName namespace
  603.     ODValueNameSpace* userStringNameSpace = 
  604.         (ODValueNameSpace*)_fNmSpcMgr->HasNameSpace( ev, kODCategoryUserString );
  605.  
  606.     if (userStringNameSpace)
  607.         result = ValueNameSpaceGetODName(userStringNameSpace, ev, category, &userString );
  608.     
  609.     if (userString)
  610.         *name = *userString;
  611.     else
  612.         InitIText(name);
  613.  
  614.     SOM_CATCH_ALL
  615.     SOM_ENDTRY
  616.     
  617.     return result ;
  618. }
  619.  
  620. SOM_Scope ODBoolean  SOMLINK ODBindingEditorSupportsKind(ODBinding *somSelf, Environment *ev,
  621.         ODEditor editor,
  622.         ODKind kind)
  623. {
  624.     ODBindingData *somThis = ODBindingGetData(somSelf);
  625.     ODBindingMethodDebug("ODBinding","ODBindingEditorSupportsKind");
  626.  
  627.     ODBoolean    result = kODFalse;
  628.  
  629.     SOM_TRY
  630.     
  631.         // get the editorkinds namespace
  632.     ODObjectNameSpace* editorkindsNameSpace = 
  633.         (ODObjectNameSpace*)_fNmSpcMgr->HasNameSpace( ev, kODEditorKinds );
  634.     
  635.     ODTypeList*    kindsList = kODNULL;
  636.  
  637.     if (editorkindsNameSpace)
  638.     {
  639.             // Lookup the kinds list by editor class ID
  640.         if (!editorkindsNameSpace->GetEntry( ev, (ODISOStr)editor, 
  641.                                     (ODObject**)&kindsList ))
  642.             kindsList = (ODTypeList*)kODNULL;
  643.     }
  644.  
  645.     result    = (kindsList && kindsList->Contains(ev, kind));
  646.     
  647.     SOM_CATCH_ALL
  648.     SOM_ENDTRY
  649.     
  650.     return result;
  651. }
  652.  
  653. SOM_Scope void  SOMLINK ODBindingGetAllEditors(ODBinding *somSelf, Environment *ev,
  654.         ODTypeList* editorList)
  655. {
  656.     ODBindingData *somThis = ODBindingGetData(somSelf);
  657.     ODBindingMethodDebug("ODBinding","ODBindingGetAllEditors");
  658.  
  659.     ODObjectIterator* iter = kODNULL; ODVolatile(iter);
  660.     
  661.     SOM_TRY
  662.     
  663.         // get the editorkinds namespace
  664.     ODObjectNameSpace* editorkindsNameSpace = 
  665.         (ODObjectNameSpace*)_fNmSpcMgr->HasNameSpace( ev, kODEditorKinds );
  666.     
  667.     if (editorkindsNameSpace)
  668.     {
  669.     
  670.         ODTypeList* kindsList     = kODNULL;
  671.         ODEditor     editor        = kODNULL;
  672.         ODULong        len         = 0;
  673.  
  674.         //    iterate through editorKinds namespace
  675.         iter = editorkindsNameSpace->CreateIterator(ev) ;
  676.         for (iter->First(ev, (ODISOStr*)&editor, (ODObject**)&kindsList, &len);
  677.                 iter->IsNotComplete(ev);
  678.                 iter->Next(ev, (ODISOStr*)&editor, (ODObject**)&kindsList, &len))
  679.         {
  680.             editorList->AddLast(ev, editor);
  681.         }
  682.         
  683.         ODDeleteObject( iter );
  684.     }
  685.     
  686.     SOM_CATCH_ALL
  687.         ODDeleteObject( iter );
  688.     SOM_ENDTRY
  689. }
  690.  
  691. SOM_Scope ODOSType  SOMLINK ODBindingGetODOSTypeForKind(ODBinding *somSelf, Environment *ev,
  692.         ODType kind)
  693. {
  694.     ODBindingData *somThis = ODBindingGetData(somSelf);
  695.     ODBindingMethodDebug("ODBinding","ODBindingODGetODOSTypeForKind");
  696.  
  697.     ODOSType theOSType = kODNULL;
  698.     
  699.     SOM_TRY
  700.     
  701.         // look it up in the editorkinds namespace
  702.     ODValueNameSpace* kindOldMacOSTypeNameSpace = 
  703.         (ODValueNameSpace*)_fNmSpcMgr->HasNameSpace( ev, 
  704.                                                    kODKindOldMacOSType );
  705.     
  706.     if (kindOldMacOSTypeNameSpace)
  707.     {
  708.         ODOSType*     typePtr        = kODNULL;
  709.         ODULong        valueLen     = 0;
  710.         if (ValueNameSpaceGetEntry( 
  711.                                 kindOldMacOSTypeNameSpace, ev, kind, 
  712.                                 (ODPtr*) &typePtr, &valueLen ))
  713.         {
  714.             theOSType = *typePtr;
  715.             ODDeleteObject( typePtr );
  716.         }
  717.     }
  718.     
  719.     SOM_CATCH_ALL
  720.     SOM_ENDTRY
  721.     
  722.     return theOSType;
  723. }
  724.  
  725. SOM_Scope void  SOMLINK ODBindingsomUninit(ODBinding *somSelf)
  726. {
  727.     ODBindingData *somThis = ODBindingGetData(somSelf);
  728.     ODBindingMethodDebug("ODBinding","ODBindingsomUninit");
  729.  
  730.     ODDeleteObject( _fBinding );
  731.     
  732.     ODBinding_parent_ODObject_somUninit(somSelf);
  733. }
  734.  
  735. SOM_Scope ODSize  SOMLINK ODBindingPurge(ODBinding *somSelf, Environment *ev,
  736.         ODSize size)
  737. {
  738.     ODBindingData *somThis = ODBindingGetData(somSelf);
  739.     ODBindingMethodDebug("ODBinding","ODBindingPurge");
  740.  
  741.     ODSize returnVal = 0; ODVolatile( returnVal );
  742.  
  743.     SOM_TRY
  744.  
  745.         returnVal = _fBinding->Purge(size);
  746.  
  747.     SOM_CATCH_ALL
  748.         WARN("Error %ld trying to purge in ODBindingPurge",ErrorCode());
  749.         SetErrorCode(kODNoError);        // dh - Eat the exception; Purge should not 
  750.                                         // propagate it because clients function
  751.                                         // fine whether memory was purged or not.
  752.     SOM_ENDTRY
  753.  
  754.     return(returnVal);
  755. }
  756.